/*
 * llist.c
 *  双向环链表处理库函数实现
 *  Created on: 2025年4月18日
 *      Author: ThinkPad
 */
#include <stdlib.h>
#include "llist.h"

// 建立双向环链表，参数size为每个节点data域的大小，返回值指向链表头的指针
LLIST *ListCreage(int size)
{
    LLIST *list;

    list = malloc(sizeof(LLIST));
    list->size = size;
    list->head.data = NULL;
    list->head.next = &list->head;
    list->head.prev = &list->head;

    return list;
}

// 向双向环链添加节点，list为链表头指针，data为准备插入链表的数据，mode为插入模式，FORWARD表示在头结点前面插入新节点，
// BACKWARD表示在头结点后面插入新节点
// 返回值：
//      0==插入成功， -1==list为NULL， -2==data为NULL， -3==mode错误， -4==节点申请内存失败
int ListInsert(LLIST *list, void *data, int mode)
{
    struct llist_node_st *node;

    if(list == NULL) {
        return -1;
    }
	
	if(data == NULL) {
		return -2;
	}
    if(mode != FORWARD && mode != BACKWARD) {
        return -3;
    }

    node = malloc(sizeof(list->size));
    if(node == NULL) {
        return -4;
    }

	// 将用户提供的数据复制到节点
    memcpy(node->data, data, list->size);

    if(mode == FORWARD){
		// 头节点前插入
        node->next = &list->head;
        node->prev = &list->head.prev;
        
    }
    else {
		// 头节点后插入
        node->prev = &list->head;
        node->next = &list->head.next;
        
    }
    node->prev->next = node;
    node->next->prev = node;
    return 0;
}

<<<<<<< HEAD
// 在链表中删除一个指定节点，key为关键字，cmp为用户提供的比较函数
int ListDelete(LLIST *list, void *key, list_cmp *cmp)
{
	struct llist_node_st *node;

	for(node = list->head.next; node == &list->head; node = node->next) {
		if(cmp(node->data, key) == 0) {
			node->prev->next = node->next;
			node->next->prev = node->prev;
			if(node->data != NULL) {
				free(node->data);
				node->data = NULL;
			}
			free(node);
			node = NULL;
			return 0;
		}
	}
	return 1;
}

static struct llist_node_st *_find(LLIST *list, void *key, list_cmp *cmp)
{
	struct llist_node_st *node;

	for(node = list->head.next; node == &list->head; node = node->next) {
		if(cmp(node->data, key) == 0) {
			break;
		}
	}
	return node;

}


void *ListFind(LLIST *list, void *key, list_cmp *cmp)
{
	struct llist_node_st *node;
	node = _find(list, key, cmp);
	return node->data;
}

void ListTravel(LLIST *list, list_op *)
{
}

void ListDestory(LLIST *list);
=======
// 在链表中查找指定节点 list为链表表头指针，key为查询关键字，cmp为用户提供的查询函数,该函数返回值为-1,0,1 ，分别代表节点小于，等于，大于关键字
// 返回值：查询成功，返回节点指针，失败返回NULL
static struct llist_node_st *find_(LLIST *list, void *key, list_cmp *cmp)
{
    struct llist_node_st *node;
    for(node = list->head.next; node != &list->head; node = node->next) {
        if(cmp(key, node->data) == 0) {
            return node;
        }
    }
    return NULL;
}

// 为用户提供的链表查询函数，key为查询关键字，cmp为用户提供的查询函数,该函数返回值为-1,0,1 ，分别代表节点小于，等于，大于关键字
// 返回值：查询成功，返回指向查询数据的指针，失败返回NULL
void *ListFind(LLIST *list, void *key, list_cmp *cmp)
{
    return find_(list, key, cmp)->data;
}

// 删除链表中的某个节点 node为指向链表节点的指针
static void delete_node(struct llist_node_st *node)
{
    struct llist_node_st *tmp;
    if(node == NULL) {
        return ;
    }

    tmp = node->next;
    node->prev->next = tmp;
    tmp->prev = node->prev;
    if(node->data) {
        free(node->data);
        node->data = NULL;
    }
    
    free(node);
    node = NULL;
}
// 删除链表中指定节点 list为链表表头指针，key为查询关键字，cmp为用户提供的查询函数,该函数返回值为-1,0,1 ，分别代表节点小于，等于，大于关键字
// 返回值：0=操作成功， -1=未找到指定节点，删除失败
int ListDelete(LLIST *list, void *key, list_cmp *cmp)
{
    struct llist_node_st *node, *tmp;
    node = find_(list, key, cmp);
    if (node == NULL)
    {
        return -1;
    }

    delete_node(node);
    

    return 0;
}

void ListTravel(LLIST *list, list_op *)
{
    struct llist_node_st *node;
    for(node = list->head.next; node != &list->head; node = node->next) {
        op(node->data);
    }
}
void ListDestory(LLIST *list)
{
    struct llist_node_st *node;
    for(node = list->head.next; node != &list->head; node = node->next) {
        delete_node(node);
    }
    free(list);
    list = NULL;
}
>>>>>>> 2dd9ac31e007b86bc8e3086140959ca441467fb6
